{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "HEmYWqWOT_U0"
      ],
      "gpuType": "T4"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Vision Transformers"
      ],
      "metadata": {
        "id": "LAsvfaZRCEaM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "In this notebook we are going to implement ViT from scratch for image classification using PyTorch.\n",
        "We will start by transforming the images into embeddings, then we will use Transformer Encoders and an MLP Head to create the ViT Architecture.\n",
        "\n",
        " [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/SharifiZarchi/Introduction_to_Machine_Learning/blob/main/Jupyter_Notebooks/Chapter_06_Contrastive_Learning/ViT.ipynb)\n",
        "[![Open In kaggle](https://kaggle.com/static/images/open-in-kaggle.svg)](https://kaggle.com/kernels/welcome?src=https://raw.githubusercontent.com/SharifiZarchi/Introduction_to_Machine_Learning/main/Jupyter_Notebooks/Chapter_06_Contrastive_Learning/ViT.ipynb)\n"
      ],
      "metadata": {
        "id": "gjsiH-JNTQsG"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "cellView": "form",
        "id": "l_JlLMVQB7IS"
      },
      "outputs": [],
      "source": [
        "# @title setup and imports\n",
        "\n",
        "from matplotlib import pyplot as plt\n",
        "from tqdm import trange\n",
        "\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "from torch.optim import Adam\n",
        "from torch.nn import CrossEntropyLoss\n",
        "from torch.utils.data import DataLoader\n",
        "\n",
        "from torchvision import transforms\n",
        "from torchvision.datasets.cifar import CIFAR10\n",
        "\n",
        "torch.manual_seed(0)\n",
        "\n",
        "device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# @title helper functions\n",
        "\n",
        "def train_epoch(model, dataloader, loss_fn, optimizer, device):\n",
        "    model.train()\n",
        "    train_loss = 0.\n",
        "    train_acc = 0.\n",
        "    for images, labels in dataloader:\n",
        "        images, labels = images.to(device), labels.to(device)\n",
        "        logits = model(images)\n",
        "        loss = loss_fn(logits, labels)\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        optimizer.zero_grad()\n",
        "        train_loss += loss.item()\n",
        "        train_acc += (logits.argmax(dim=1) == labels).sum().item()\n",
        "    train_loss /= len(dataloader)\n",
        "    train_acc /= len(dataloader.dataset)\n",
        "    return train_loss, train_acc\n",
        "\n",
        "\n",
        "def validate_epoch(model, dataloader, loss_fn, device):\n",
        "    model.eval()\n",
        "    val_loss = 0.\n",
        "    val_acc = 0.\n",
        "    with torch.inference_mode():\n",
        "        for images, labels in dataloader:\n",
        "            images, labels = images.to(device), labels.to(device)\n",
        "            logits = model(images)\n",
        "            loss = loss_fn(logits, labels)\n",
        "            val_loss += loss.item()\n",
        "            val_acc += (logits.argmax(dim=1) == labels).sum().item()\n",
        "        val_loss /= len(dataloader)\n",
        "        val_acc /= len(dataloader.dataset)\n",
        "    return val_loss, val_acc\n",
        "\n",
        "\n",
        "def train_model(model, train_dataloader, val_dataloader, optimizer, n_epochs, device=device):\n",
        "    history = {'train_loss': [], 'train_acc': [], 'val_loss': [], 'val_acc': []}\n",
        "    loss_fn = CrossEntropyLoss()\n",
        "    for _ in (pbar := trange(n_epochs)):\n",
        "        train_loss, train_acc = train_epoch(model, train_dataloader, loss_fn, optimizer, device)\n",
        "        history['train_loss'].append(train_loss), history['train_acc'].append(train_acc)\n",
        "        val_loss, val_acc = validate_epoch(model, val_dataloader, loss_fn, device)\n",
        "        history['val_loss'].append(val_loss), history['val_acc'].append(val_acc)\n",
        "        pbar.set_description(f'Training Accuracy {100 * train_acc:.2f}% | Validation Accuracy {100 * val_acc:.2f}% ')\n",
        "    return history\n",
        "\n",
        "\n",
        "def plot_history(history):\n",
        "    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 5))\n",
        "    ax1.plot(history['train_loss'], label='train')\n",
        "    ax1.plot(history['val_loss'], label='val')\n",
        "    ax1.set_xlabel('Epochs')\n",
        "    ax1.set_ylabel('Loss')\n",
        "    ax1.legend()\n",
        "\n",
        "    ax2.plot(history['train_acc'], label='train')\n",
        "    ax2.plot(history['val_acc'], label='val')\n",
        "    ax2.set_xlabel('Epochs')\n",
        "    ax2.set_ylabel('Accuracy')\n",
        "    ax2.legend()\n",
        "    plt.show()"
      ],
      "metadata": {
        "cellView": "form",
        "id": "0PaqVBCygpEl"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# @title CIFAR10 dataset\n",
        "\n",
        "norm_mean = (0.4914, 0.4822, 0.4465)\n",
        "norm_std = (0.2023, 0.1994, 0.2010)\n",
        "batch_size = 128\n",
        "\n",
        "transform_train = transforms.Compose([\n",
        "    transforms.RandomCrop(32, padding=4),\n",
        "    transforms.RandomHorizontalFlip(),\n",
        "    transforms.ToTensor(),\n",
        "    transforms.Normalize(norm_mean, norm_std),\n",
        "])\n",
        "\n",
        "transform_test = transforms.Compose([\n",
        "    transforms.ToTensor(),\n",
        "    transforms.Normalize(norm_mean, norm_std),\n",
        "])\n",
        "\n",
        "trainset = CIFAR10(root='./data', train=True, download=True, transform=transform_train)\n",
        "trainloader = DataLoader(trainset, batch_size=batch_size, shuffle=True, num_workers=2)\n",
        "\n",
        "testset = CIFAR10(root='./data', train=False, download=True, transform=transform_test)\n",
        "testloader = DataLoader(testset, batch_size=batch_size, shuffle=False, num_workers=2)\n",
        "\n",
        "\n",
        "classes = ('plane', 'car', 'bird', 'cat', 'deer',\n",
        "           'dog', 'frog', 'horse', 'ship', 'truck')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "cellView": "form",
        "id": "zykSHg17eouX",
        "outputId": "85e02ac3-7412-4e0c-e608-f5d0d6ad9ac7"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Files already downloaded and verified\n",
            "Files already downloaded and verified\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Patch + Position Embedding"
      ],
      "metadata": {
        "id": "HEmYWqWOT_U0"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "In order to feed input images to a Transformer model, we need to convert the images to a sequence of vectors. This is done by splitting the image into a grid of non-overlapping patches, which are then linearly projected to obtain a fixed-size embedding vector for each patch. We can use PyTorch's `nn.Conv2d` layer for this purpose:"
      ],
      "metadata": {
        "id": "q_ERUFUDTfMZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class PatchEmbeddings(nn.Module):\n",
        "    \"\"\"\n",
        "    Convert the image into patches and then project them into a vector space.\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, image_size, patch_size, num_channels, hidden_size):\n",
        "        super().__init__()\n",
        "        # Calculate the number of patches from the image size and patch size\n",
        "        self.num_patches = (image_size // patch_size) ** 2\n",
        "        # Create a projection layer to convert the image into patches\n",
        "        # The layer projects each patch into a vector of size hidden_size\n",
        "        self.projection = nn.Conv2d(num_channels, hidden_size, kernel_size=patch_size, stride=patch_size)\n",
        "\n",
        "    def forward(self, x):\n",
        "        # (batch_size, num_channels, image_size, image_size) -> (batch_size, num_patches, hidden_size)\n",
        "        x = self.projection(x)\n",
        "        x = x.flatten(2).transpose(1, 2)\n",
        "        return x"
      ],
      "metadata": {
        "id": "UKZwmm37CvqW"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "`kernel_size=self.patch_size` and `stride=self.patch_size` are to make sure the layer's filter is applied to non-overlapping patches.\n",
        "\n",
        "After the patches are converted to a sequence of embeddings, the [CLS] token is added to the beginning of the sequence, it will be used later in the classification layer to classify the image. The [CLS] token's embedding is learned during training.\n",
        "\n",
        "As patches from different positions may contribute differently to the final predictions, we also need a way to encode patch positions into the sequence. We're going to use learnable position embeddings to add positional information to the embeddings. This is similar to how position embeddings are used in Transformer models for NLP tasks."
      ],
      "metadata": {
        "id": "mtCefUFkTwNH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Embeddings(nn.Module):\n",
        "    \"\"\"\n",
        "    Combine the patch embeddings with the class token and position embeddings.\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, image_size, patch_size, num_channels, hidden_size, hidden_dropout_prob):\n",
        "        super().__init__()\n",
        "        self.patch_embeddings = PatchEmbeddings(image_size, patch_size, num_channels, hidden_size)\n",
        "        # Create a learnable [CLS] token\n",
        "        # Similar to BERT, the [CLS] token is added to the beginning of\n",
        "        # the input sequence and is used to classify the entire sequence\n",
        "        self.cls_token = nn.Parameter(torch.randn(1, 1, hidden_size))\n",
        "        # Create position embeddings for the [CLS] token and the patch embeddings\n",
        "        # Add 1 to the sequence length for the [CLS] token\n",
        "        self.position_embeddings = nn.Parameter(torch.randn(1, self.patch_embeddings.num_patches + 1, hidden_size))\n",
        "        self.dropout = nn.Dropout(hidden_dropout_prob)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.patch_embeddings(x)\n",
        "        batch_size, _, _ = x.size()\n",
        "        # Expand the [CLS] token to the batch size (1, 1, hidden_size) -> (batch_size, 1, hidden_size)\n",
        "        cls_tokens = self.cls_token.expand(batch_size, -1, -1)\n",
        "        # Concatenate the [CLS] token to the beginning of the input sequence\n",
        "        # This results in a sequence length of (num_patches + 1)\n",
        "        x = torch.cat((cls_tokens, x), dim=1)\n",
        "        x = x + self.position_embeddings\n",
        "        x = self.dropout(x)\n",
        "        return x"
      ],
      "metadata": {
        "id": "EGim7hr9C1c-"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Vision Transformer (ViT)"
      ],
      "metadata": {
        "id": "uKElOeEfUWTq"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The following code implements the ViT model for image classification according to:\n",
        "\n",
        "![vit-figure](https://github.com/google-research/vision_transformer/raw/main/vit_figure.png)"
      ],
      "metadata": {
        "id": "MafJ27talBTW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class ViT(nn.Module):\n",
        "    \"\"\"\n",
        "    The ViT model for classification.\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, image_size, patch_size, num_channels, hidden_size, num_heads, num_layers, mlp_dim, num_classes, dropout_rate=0.1):\n",
        "        super().__init__()\n",
        "\n",
        "        # Step 1: Embedding module (Patch + Position + CLS token)\n",
        "        self.embeddings = Embeddings(image_size, patch_size, num_channels, hidden_size, dropout_rate)\n",
        "\n",
        "        # Step 2: Transformer Encoder using PyTorch's built-in nn.TransformerEncoder\n",
        "        encoder_layer = nn.TransformerEncoderLayer(\n",
        "            d_model=hidden_size,       # the number of expected features in the input\n",
        "            nhead=num_heads,           # the number of heads in the multiheadattention models\n",
        "            dim_feedforward=mlp_dim,   # the dimension of the feedforward network model\n",
        "            dropout=dropout_rate,      # the dropout value\n",
        "            activation='gelu',          # the activation function of the intermediate layer\n",
        "            batch_first = True\n",
        "        )\n",
        "        self.encoder = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)\n",
        "\n",
        "        # Step 3: Classification head (MLP head)\n",
        "        self.mlp_head = nn.Sequential(\n",
        "            nn.LayerNorm(hidden_size),\n",
        "            nn.Linear(hidden_size, num_classes)\n",
        "        )\n",
        "\n",
        "    def forward(self, x):\n",
        "        # Step 1: Get patch + position embeddings and cls token\n",
        "        x = self.embeddings(x)\n",
        "\n",
        "        # Step 2: Pass through the transformer encoder\n",
        "        x = self.encoder(x)\n",
        "\n",
        "        # Step 3: Classification token is at position 0 of the sequence\n",
        "        cls_token_output = x[:, 0]\n",
        "\n",
        "        # Step 4: Pass through MLP classification head\n",
        "        logits = self.mlp_head(cls_token_output)\n",
        "        return logits"
      ],
      "metadata": {
        "id": "zpvJ-56XC4yp"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Training"
      ],
      "metadata": {
        "id": "EjOMyEpmebtQ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "All that remains to be done is to train the model and plot its performance. To do so we use the helper functions `train_model` and `plot_history`."
      ],
      "metadata": {
        "id": "uIUdEPQdlzTs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "parameters = {\n",
        "    'image_size': 32,\n",
        "    'patch_size': 4,\n",
        "    'num_channels': 3,\n",
        "    'hidden_size': 128,\n",
        "    'num_heads': 8,\n",
        "    'num_layers': 6,\n",
        "    'mlp_dim': 256,\n",
        "    'num_classes': 10,\n",
        "    'dropout_rate': 0.1,\n",
        "}\n",
        "\n",
        "vit = ViT(**parameters).to(device)\n",
        "if device == 'cuda':\n",
        "    vit = torch.compile(vit)\n",
        "optim = Adam(vit.parameters(), lr=1e-3)\n",
        "\n",
        "results = train_model(vit, trainloader, testloader, optim, n_epochs=30)\n",
        "plot_history(results)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 482
        },
        "id": "nY4f69uMebYZ",
        "outputId": "513eee8c-17df-41fe-bd17-6b89dceb16b6"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Training Accuracy 74.57% | Validation Accuracy 74.23% : 100%|██████████| 30/30 [15:02<00:00, 30.07s/it]\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1500x500 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Refrences\n",
        "\n",
        "\n",
        "*   [An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale](https://arxiv.org/abs/2010.11929) paper and its [github repository](https://github.com/google-research/vision_transformer)\n",
        "*   [Implementing Vision Transformer (ViT) from Scratch](https://tintn.github.io/Implementing-Vision-Transformer-from-Scratch/)\n",
        "\n"
      ],
      "metadata": {
        "id": "LR8IOITCmTSu"
      }
    }
  ]
}
